home *** CD-ROM | disk | FTP | other *** search
/ Programming Languages Suite / ProgramD2.iso / Borland / Borland C++ V5.02 / OWLSRC.PAK / WINSOCK.CPP < prev    next >
Encoding:
C/C++ Source or Header  |  1997-05-06  |  11.8 KB  |  438 lines
  1. //----------------------------------------------------------------------------
  2. // ObjectWindows
  3. // Copyright (c) 1995, 1997 by Borland International, All Rights Reserved
  4. //
  5. //$Revision:   10.8  $
  6. //
  7. // Implementation of TWinSockDll, a WinSock dll loader & wrapper
  8. //----------------------------------------------------------------------------
  9. #include <owl/pch.h>
  10. #if !defined(OWL_WINSOCK_H)
  11. # include <owl/winsock.h>
  12. #endif
  13. #if !defined(OWL_MODULE_H)
  14. # include <owl/module.h>
  15. #endif
  16.  
  17. OWL_DIAGINFO;
  18.  
  19. #if defined(BI_PLAT_WIN32)
  20.   static char WinSockDllName[] = "WSock32.dll";
  21. #else
  22.   static char WinSockDllName[] = "Winsock.dll";
  23. #endif
  24.  
  25. //
  26. // Construct wrapper object and load DLL
  27. //
  28.  
  29. TWinSockDll::TWinSockDll()
  30. :
  31.   TModule(WinSockDllName, true, true)
  32. {}
  33.  
  34. //
  35. //  Standard socket functions
  36. //
  37.  
  38. SOCKET
  39. TWinSockDll::accept(SOCKET s, struct sockaddr far* addr, int far* addrLen)
  40. {
  41.   static TModuleProc3<SOCKET,SOCKET,struct sockaddr far*, int far*>
  42.     accept(WinSockModule(), "accept");
  43.   return accept(s, addr, addrLen);
  44. }
  45.  
  46. int
  47. TWinSockDll::bind(SOCKET s, struct sockaddr far* addr, int nameLen)
  48. {
  49.   static TModuleProc3<int,SOCKET,struct sockaddr far*,int>
  50.     bind(WinSockModule(), "bind");
  51.   return bind(s, addr, nameLen);
  52. }
  53.  
  54. int
  55. TWinSockDll::closesocket(SOCKET s)
  56. {
  57.   static TModuleProc1<int,SOCKET> closesocket(WinSockModule(), "closesocket");
  58.   return closesocket(s);
  59. }
  60.  
  61. int
  62. TWinSockDll::connect(SOCKET s, struct sockaddr far* name, int nameLen)
  63. {
  64.   static TModuleProc3<int,SOCKET,struct sockaddr far*,int>
  65.     connect(WinSockModule(), "connect");
  66.   return connect(s, name, nameLen);
  67. }
  68.  
  69. int
  70. TWinSockDll::getpeername(SOCKET s, struct sockaddr far* name, int far* nameLen)
  71. {
  72.   static TModuleProc3<int,SOCKET,struct sockaddr far*,int far*>
  73.     getpeername(WinSockModule(), "getpeername");
  74.   return getpeername(s, name, nameLen);
  75. }
  76.  
  77. int
  78. TWinSockDll::getsockname(SOCKET s, struct sockaddr far* name, int far* nameLen)
  79. {
  80.   static TModuleProc3<int,SOCKET,struct sockaddr far*,int far*>
  81.     getsockname(WinSockModule(), "getsockname");
  82.   return getsockname(s, name, nameLen);
  83. }
  84.  
  85. int
  86. TWinSockDll::getsockopt(SOCKET s, int level, int optName, char far* optVal, int far* optLen)
  87. {
  88.   static TModuleProc5<int,SOCKET,int,int,char far*,int far*>
  89.     getsockopt(WinSockModule(), "getsockopt");
  90.   return getsockopt(s, level, optName, optVal, optLen);
  91. }
  92.  
  93. ulong
  94. TWinSockDll::htonl(ulong hostLong)
  95. {
  96.   static TModuleProc1<ulong,ulong> htonl(WinSockModule(), "htonl");
  97.   return htonl(hostLong);
  98. }
  99.  
  100. ushort
  101. TWinSockDll::htons(ushort hostShort)
  102. {
  103.   static TModuleProc1<ushort,ushort> htons(WinSockModule(), "htons");
  104.   return htons(hostShort);
  105. }
  106.  
  107. ulong
  108. TWinSockDll::inet_addr(const char far* cp)
  109. {
  110.   static TModuleProc1<ulong,const char far*> inet_addr(WinSockModule(), "inet_addr");
  111.   return inet_addr(cp);
  112. }
  113.  
  114. char far*
  115. TWinSockDll::inet_ntoa(struct in_addr in)
  116. {
  117.   static TModuleProc1<char far*,struct in_addr> inet_ntoa(WinSockModule(), "inet_ntoa");
  118.   return inet_ntoa(in);
  119. }
  120.  
  121. int
  122. TWinSockDll::ioctlsocket(SOCKET s, long cmd, ulong far* argp)
  123. {
  124.   static TModuleProc3<int,SOCKET,long,ulong far*>
  125.     ioctlsocket(WinSockModule(), "ioctlsocket");
  126.   return ioctlsocket(s, cmd, argp);
  127. }
  128.  
  129. int
  130. TWinSockDll::listen(SOCKET s, int backlog)
  131. {
  132.   static TModuleProc2<int,SOCKET,int> listen(WinSockModule(), "listen");
  133.   return listen(s, backlog);
  134. }
  135.  
  136. ulong
  137. TWinSockDll::ntohl(ulong netLong)
  138. {
  139.   static TModuleProc1<ulong,ulong> ntohl(WinSockModule(), "ntohl");
  140.   return ntohl(netLong);
  141. }
  142.  
  143. ushort
  144. TWinSockDll::ntohs(ushort netShort)
  145. {
  146.   static TModuleProc1<ushort,ushort> ntohs(WinSockModule(), "ntohs");
  147.   return ntohs(netShort);
  148. }
  149.  
  150. int
  151. TWinSockDll::recv(SOCKET s, char far* buf, int len, int flags)
  152. {
  153.   static TModuleProc4<int,SOCKET,char far*,int,int> recv(WinSockModule(), "recv");
  154.   return recv(s, buf, len, flags);
  155. }
  156.  
  157. int
  158. TWinSockDll::recvfrom(SOCKET s, char far* buf, int len, int flags,
  159.   struct sockaddr far* from, int* fromLen)
  160. {
  161.   static TModuleProc6<int,SOCKET,char far*,int,int,struct sockaddr far*,int*>
  162.     recvfrom(WinSockModule(), "recvfrom");
  163.   return recvfrom(s, buf, len, flags, from, fromLen);
  164. }
  165.  
  166. int
  167. TWinSockDll::select(int nfds, struct fd_set far* readfds,
  168.   struct fd_set far* writefds, struct fd_set far* exceptfds,
  169.   const struct timeval far* timeout)
  170. {
  171.   static TModuleProc5<int,int,struct fd_set far*,struct fd_set far*,
  172.     struct fd_set far*,const struct timeval far*> select(WinSockModule(), "select");
  173.   return select(nfds, readfds, writefds, exceptfds, timeout);
  174. }
  175.  
  176. int
  177. TWinSockDll::send(SOCKET s, const char far* buf, int len, int flags)
  178. {
  179.   static TModuleProc4<int,SOCKET,const char far*,int,int> send(WinSockModule(), "send");
  180.   return send(s, buf, len, flags);
  181. }
  182.  
  183. int
  184. TWinSockDll::sendto(SOCKET s, const char far* buf, int len, int flags,
  185.   const struct sockaddr far* to, int toLen)
  186. {
  187.   static TModuleProc6<int,SOCKET,const char far*,int,int,
  188.     const struct sockaddr far*,int> sendto(WinSockModule(), "sendto");
  189.   return sendto(s, buf, len, flags, to, toLen);
  190. }
  191.  
  192. int
  193. TWinSockDll::setsockopt(SOCKET s, int level, int optName,
  194.   const char far* optVal, int optLen)
  195. {
  196.   static TModuleProc5<int,SOCKET,int,int,const char far*,int>
  197.     setsockopt(WinSockModule(), "setsockopt");
  198.   return setsockopt(s, level, optName, optVal, optLen);
  199. }
  200.  
  201. int
  202. TWinSockDll::shutdown(SOCKET s, int how)
  203. {
  204.   static TModuleProc2<int,SOCKET,int> shutdown(WinSockModule(), "shutdown");
  205.   return shutdown(s, how);
  206. }
  207.  
  208. SOCKET
  209. TWinSockDll::socket(int af, int type, int protocol)
  210. {
  211.   static TModuleProc3<SOCKET,int,int,int> socket(WinSockModule(), "socket");
  212.   return socket(af, type, protocol);
  213. }
  214.  
  215. //
  216. // Database functions
  217. //
  218.  
  219. struct hostent far*
  220. TWinSockDll::gethostbyaddr(const char far* addr, int len, int type)
  221. {
  222.   static TModuleProc3<struct hostent far*,const char far*,int,int>
  223.     gethostbyaddr(WinSockModule(), "gethostbyaddr");
  224.   return gethostbyaddr(addr, len, type);
  225. }
  226.  
  227. struct hostent far*
  228. TWinSockDll::gethostbyname(const char far* name)
  229. {
  230.   static TModuleProc1<struct hostent far*,const char far*>
  231.     gethostbyname(WinSockModule(), "gethostbyname");
  232.   return gethostbyname(name);
  233. }
  234.  
  235. int
  236. TWinSockDll::gethostname(char far* name, int nameLen)
  237. {
  238.   static TModuleProc2<int,char far*,int> gethostname(WinSockModule(), "gethostname");
  239.   return gethostname(name, nameLen);
  240. }
  241.  
  242. struct servent far*
  243. TWinSockDll::getservbyname(const char far* name, const char far* proto)
  244. {
  245.   static TModuleProc2<struct servent far*,const char far*, const char far*>
  246.     getservbyname(WinSockModule(), "getservbyname");
  247.   return getservbyname(name, proto);
  248. }
  249.  
  250. struct servent far*
  251. TWinSockDll::getservbyport(int port, const char far* proto)
  252. {
  253.   static TModuleProc2<struct servent far*,int,const char far*>
  254.     getservbyport(WinSockModule(), "getservbyport");
  255.   return getservbyport(port, proto);
  256. }
  257.  
  258. struct protoent far*
  259. TWinSockDll::getprotobyname(const char far* name)
  260. {
  261.   static TModuleProc1<struct protoent far*, const char far*>
  262.     getprotobyname(WinSockModule(), "getprotobyname");
  263.   return getprotobyname(name);
  264. }
  265.  
  266. struct protoent far*
  267. TWinSockDll::getprotobynumber(int proto)
  268. {
  269.   static TModuleProc1<struct protoent far*, int>
  270.     getprotobynumber(WinSockModule(), "getprotobynumber");
  271.   return getprotobynumber(proto);
  272. }
  273.  
  274. //
  275. // Microsoft Windows Extension functions
  276. //
  277.  
  278. int
  279. TWinSockDll::WSAStartup(uint16 versionRequested, LPWSADATA WSAData)
  280. {
  281.   static TModuleProc2<int,uint16,LPWSADATA> WSAStartup(WinSockModule(), "WSAStartup");
  282.   return WSAStartup(versionRequested, WSAData);
  283. }
  284.  
  285. int
  286. TWinSockDll::WSACleanup(void)
  287. {
  288.   static TModuleProc0<int> WSACleanup(WinSockModule(), "WSACleanup");
  289.   return WSACleanup();
  290. }
  291.  
  292. void
  293. TWinSockDll::WSASetLastError(int error)
  294. {
  295.   static TModuleProcV1<int> WSASetLastError(WinSockModule(), "WSASetLastError");
  296.   WSASetLastError(error);
  297. }
  298.  
  299. int
  300. TWinSockDll::WSAGetLastError(void)
  301. {
  302.   static TModuleProc0<int> WSAGetLastError(WinSockModule(), "WSAGetLastError");
  303.   return WSAGetLastError();
  304. }
  305.  
  306. BOOL
  307. TWinSockDll::WSAIsBlocking(void)
  308. {
  309.   static TModuleProc0<int> WSAIsBlocking(WinSockModule(), "WSAIsBlocking");
  310.   return WSAIsBlocking();
  311. }
  312.  
  313. int
  314. TWinSockDll::WSAUnhookBlockingHook(void)
  315. {
  316.   static TModuleProc0<int> WSAUnhookBlockingHook(WinSockModule(), "WSAUnhookBlockingHook");
  317.   return WSAUnhookBlockingHook();
  318. }
  319.  
  320. FARPROC
  321. TWinSockDll::WSASetBlockingHook(FARPROC blockFunc)
  322. {
  323.   static TModuleProc1<FARPROC,FARPROC>
  324.     WSASetBlockingHook(WinSockModule(), "WSASetBlockingHook");
  325.   return WSASetBlockingHook(blockFunc);
  326. }
  327.  
  328. int
  329. TWinSockDll::WSACancelBlockingCall(void)
  330. {
  331.   static TModuleProc0<int> WSACancelBlockingCall(WinSockModule(), "WSACancelBlockingCall");
  332.   return WSACancelBlockingCall();
  333. }
  334.  
  335. HANDLE
  336. TWinSockDll::WSAAsyncGetServByName(HWND hWnd, uint msg, const char far* name,
  337.   const char far* proto, char far* buf, int bufLen)
  338. {
  339.   static TModuleProc6<HANDLE,HWND,uint,const char far*,const char far*,
  340.     char far*,int> WSAAsyncGetServByName(WinSockModule(), "WSAAsyncGetServByName");
  341.   return WSAAsyncGetServByName(hWnd, msg, name, proto, buf, bufLen);
  342. }
  343.  
  344. HANDLE
  345. TWinSockDll::WSAAsyncGetServByPort(HWND hWnd, uint msg, int port,
  346.   const char far* proto, char far* buf, int bufLen)
  347. {
  348.   static TModuleProc6<HANDLE,HWND,uint,int,const char far*,char far*,int>
  349.     WSAAsyncGetServByPort(WinSockModule(), "WSAAsyncGetServByPort");
  350.   return WSAAsyncGetServByPort(hWnd, msg, port, proto, buf, bufLen);
  351. }
  352.  
  353. HANDLE
  354. TWinSockDll::WSAAsyncGetProtoByName(HWND hWnd, uint msg, const char far* name,
  355.   char far* buf, int bufLen)
  356. {
  357.   static TModuleProc5<HANDLE,HWND,uint,const char far*,char far*,int>
  358.     WSAAsyncGetProtoByName(WinSockModule(), "WSAAsyncGetProtoByName");
  359.   return WSAAsyncGetProtoByName(hWnd, msg, name, buf, bufLen);
  360. }
  361.  
  362. HANDLE
  363. TWinSockDll::WSAAsyncGetProtoByNumber(HWND hWnd, uint msg, int number,
  364.   char far* buf, int bufLen)
  365. {
  366.   static TModuleProc5<HANDLE,HWND,uint,int,char far*,int>
  367.     WSAAsyncGetProtoByNumber(WinSockModule(), "WSAAsyncGetProtoByNumber");
  368.   return WSAAsyncGetProtoByNumber(hWnd, msg, number, buf, bufLen);
  369. }
  370.  
  371. HANDLE
  372. TWinSockDll::WSAAsyncGetHostByName(HWND hWnd, uint msg, const char far* name,
  373.   char far* buf, int bufLen)
  374. {
  375.   static TModuleProc5<HANDLE,HWND,uint,const char far*,char far*,int>
  376.     WSAAsyncGetHostByName(WinSockModule(), "WSAAsyncGetHostByName");
  377.   return WSAAsyncGetHostByName(hWnd, msg, name, buf, bufLen);
  378. }
  379.  
  380. HANDLE
  381. TWinSockDll::WSAAsyncGetHostByAddr(HWND hWnd, uint msg, const char far* addr,
  382.   int len, int type, char far* buf, int bufLen)
  383. {
  384.   static TModuleProc7<HANDLE,HWND,uint,const char far*,int,int,char far*,int>
  385.     WSAAsyncGetHostByAddr(WinSockModule(), "WSAAsyncGetHostByAddr");
  386.   return WSAAsyncGetHostByAddr(hWnd, msg, addr, len, type, buf, bufLen);
  387. }
  388.  
  389. int
  390. TWinSockDll::WSACancelAsyncRequest(HANDLE hTaskHandle)
  391. {
  392.   static TModuleProc1<int,HANDLE>
  393.     WSACancelAsyncRequest(WinSockModule(), "WSACancelAsyncRequest");
  394.   return WSACancelAsyncRequest(hTaskHandle);
  395. }
  396.  
  397. int
  398. TWinSockDll::WSAAsyncSelect(SOCKET s, HWND hWnd, uint msg, long event)
  399. {
  400.   static TModuleProc4<int,SOCKET,HWND,uint,long>
  401.     WSAAsyncSelect(WinSockModule(), "WSAAsyncSelect");
  402.   return WSAAsyncSelect(s, hWnd, msg, event);
  403. }
  404.  
  405. int
  406. TWinSockDll::WSARecvEx(SOCKET s, char far* buf, int len, int far* flags)
  407. {
  408.   TModuleProc4<int,SOCKET,char far*,int,int far*> WSARecvEx(WinSockModule(), "WSARecvEx");
  409.   return WSARecvEx(s, buf, len, flags);
  410. }
  411.  
  412. TModule& 
  413. TWinSockDll::WinSockModule()
  414. {
  415.   static TModule winSockModule(WinSockDllName, true, true);
  416.   return winSockModule;
  417. }
  418.  
  419. bool 
  420. TWinSockDll::IsAvailable()
  421. {
  422.   return WinSockModule().IsLoaded();
  423. }
  424.  
  425. bool       
  426. TWinSock::IsAvailable()
  427. {
  428.   return TWinSockDll::IsAvailable();
  429. }
  430.  
  431. TWinSockDll* 
  432. TWinSock::Dll()
  433. {
  434.   static TWinSockDll winSockDll;
  435.   return &winSockDll;
  436. }
  437.  
  438.